import java.util.*;

/**
 * @Author: yuisama
 * @Date: 2021/8/5 14:40
 * @Description:
 */
public class Test {
    // 滑动窗口
    public static int lengthOfLongestSubstring(String s) {
        int max = 0;
        int l = 0;
        int r = -1;
        // 记录每个字符以及最后一次出现的索引
        Map<Character,Integer> map = new HashMap<>();
        while (l < s.length()) {
            // s[l..r]一直保存不重复的连续子字符串
            max = Math.max(max,r - l + 1);
            if (r + 1 < s.length()) {
                // 滑动窗口右侧还有下一个元素
                char c = s.charAt(r + 1);
                if (!map.containsKey(c)) {
                    // 下一个元素c仍然没有出现过，右侧区间向右滑动一个单位
                    r ++;
                    // 存储下一个没出现过的元素c以及出现的索引
                    map.put(c,r);
                }else {
                    // 此时c这个元素已经出现过，并且索引为map.get(c)
                    // 将左区间直接滑动到出现位置的下一个位置
                    l = map.get(c) + 1;
                    // 更新最后出现该元素的索引为r + 1
                    map.put(c,r + 1);
                    r ++;
                }
            }
        }
        return max;
    }

    public static void main(String[] args) {
    /*int n = scanner.nextInt();
    List<String> list = new ArrayList<>();
    while (scanner.hasNextLine()) {
        list.add(scanner.nextLine());
    }*/
        char c = '2';
        int a = c;
        System.out.println(a);

//        int n = 2;
//        List<String> list = new ArrayList<>();
//        list.add("cara");
//        list.add("car");
//
//        boolean flag1 = isDic(list,n);
//        boolean flag2 = isLen(list,n);
//        if (flag1 && !flag2) {
//            System.out.println("lexicographically");
//        } else if (!flag1 && flag2) {
//            System.out.println("lengths");
//        } else if (flag1 && flag2) {
//            System.out.println("both");
//        } else {
//            System.out.println("none");
//        }
    }

    public static boolean isDic(List<String> list, int n) {
        if (n == 0) return false;
        for (int i = 0; i < n-1; i++) {
            int len1 = list.get(i).length();
            int len2 = list.get(i+1).length();
            for (int j = 0; j < Math.min(len1,len2); j++) {
                if (list.get(i).charAt(j) > list.get(i+1).charAt(j)) {
                    return false;
                }
                if (len1 > len2 && j == Math.min(len1,len2)-1 &&list.get(i).charAt(j) == list.get(i+1).charAt(j)) {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean isLen(List<String> list, int n) {
        if (n == 0) return false;
        for (int i = 0; i < n-1; i++) {
            if (list.get(i).length() > list.get(i+1).length()) {
                return false;
            }
        }
        return true;
    }
}

// Num227-简单计算器
class Solution {
    // 存放整数的栈
    private Stack<Integer> s1 = new Stack<>();
    // 存放操作符的栈
    private Stack<Character> s2 = new Stack<>();
    // 存放操作符和优先级的映射,题目中只有加减乘除
    private Map<Character,Integer> map = new HashMap<>();
    public Solution() {
        map.put('+',1);
        map.put('-',1);
        map.put('*',2);
        map.put('/',2);
    }
    public int calculate(String s) {
        // 先去除s中所有空格
        s = s.replaceAll(" ","");
        // 遍历s
        char[] cs = s.toCharArray();
        int n = s.length();
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (isNumber(c)) {
                // 碰到数字直接入栈
                int u = 0;
                int j = i;
                // 将从 i 位置开始后面的连续数字整体取出，加入 nums
                while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');
                s1.push(u);
                i = j - 1;
            }else {
                // 此时碰到运算符
                if (s2.isEmpty()) {
                    // 栈为空或者栈顶运算符优先级小于当前运算符，直接入栈
                    s2.push(c);
                }else {
                    char top = s2.peek();
                    if (map.get(c) > map.get(top)) {
                        s2.push(c);
                        continue;
                    }
                    // 栈顶运算符 >= 当前运算符
                    // 从s1中取出两个操作数
                    while (!s2.isEmpty()) {
                        top = s2.peek();
                        if (map.get(top) >= map.get(c)) {
                            int num1 = s1.pop();
                            int num2 = s1.pop();
                            int tmpRet = cal(num2,num1,top);
                            s2.pop();
                            // 将结果压入s1，将当前运算符压入s2
                            s1.push(tmpRet);
                        }else {
                            break;
                        }
                    }
                    s2.push(c);
                }
            }
        }
        // 再计算剩下的值
        while (!s2.isEmpty()) {
            int num1 = s1.pop();
            int num2 = s1.pop();
            char c = s2.pop();
            int ret = cal(num2,num1,c);
            s1.push(ret);
        }
        // 最终s1的栈顶就是计算后的值
        return s1.pop();
    }

    public int cal(int num1,int num2,char top) {
        int ret = 0;
        if (top == '+') {
            ret = num1 + num2;
        }else if (top == '-') {
            ret = num1 - num2;
        }else if (top == '*') {
            ret = num1 * num2;
        }else {
            ret = num1 / num2;
        }
        return ret;
    }

    public boolean isNumber(char c) {
        return Character.isDigit(c);
    }
}
